package handler_sys

import (
	"fmt"
	_ "go_web/internal/model"
	"go_web/internal/model/model_sys"
	"go_web/internal/req/req_sys"
	"go_web/internal/res/res_sys"
	"go_web/internal/service/service_sys"
	"go_web/pkg/req"
	"go_web/pkg/res"
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
)

type SysDataScopeHandler struct {
	SysDataScopeService *service_sys.SysDataScopeService
}

func NewSysDataScopeHandler(SysDataScopeService *service_sys.SysDataScopeService) *SysDataScopeHandler {
	return &SysDataScopeHandler{SysDataScopeService}
}

// Detail 查询SysDataScope详情
// @Summary 查询SysDataScope详情
// @Tags SysDataScopeHandler
// @Accept json
// @Produce json
// @Param id query string true "主键ID"
// @Success 200 {object} res.R[model_sys.SysDataScope] "SysDataScope"
// @Router /sys_data_scope/detail [get]
func (h *SysDataScopeHandler) Detail(ctx *gin.Context) {
	id := ctx.Query("id")
	id64, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": "无效的ID"})
		return
	}
	SysDataScope, err := h.SysDataScopeService.Detail(ctx, id64)
	if err != nil {
		ctx.JSON(http.StatusOK, res.NewR[string]().Fail("查询不到"))
		return
	}
	ctx.JSON(http.StatusOK, res.NewR[model_sys.SysDataScope]().Ok(*SysDataScope))
}

// Page 分页查询SysDataScope
// @Summary 分页查询SysDataScope
// @Tags SysDataScopeHandler
// @Accept json
// @Produce json
// @Param queryParams query req_sys.SysDataScopePageReq false "分页请求参数"
// @Success 200 {object} res.R[res.PageRes]
// @Router /sys_data_scope/page [get]
func (h *SysDataScopeHandler) Page(ctx *gin.Context) {
	var pageReq req_sys.SysDataScopePageReq
	if err := ctx.ShouldBindQuery(&pageReq); err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	page, err := h.SysDataScopeService.Page(ctx, pageReq)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	ctx.JSON(http.StatusOK, res.NewR[res.PageRes]().Ok(*page))
}

// Add 创建SysDataScope
// @Summary 创建SysDataScope
// @Tags SysDataScopeHandler
// @Accept json
// @Produce json
// @Param jsonParams body req_sys.SysDataScopeAddReq true "SysDataScope"
// @Success 200 {object} res.R[int64] "操作结果"
// @Router /sys_data_scope/add [post]
func (h *SysDataScopeHandler) Add(ctx *gin.Context) {
	var reqSys req_sys.SysDataScopeAddReq
	if err := ctx.ShouldBindJSON(&reqSys); err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	id, err := h.SysDataScopeService.Add(ctx, reqSys)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	ctx.JSON(http.StatusOK, res.NewR[int64]().Ok(id))
}

// Edit 修改SysDataScope
// @Summary 修改SysDataScope
// @Tags SysDataScopeHandler
// @Accept json
// @Produce json
// @Param jsonParams body req_sys.SysDataScopeEditReq true "SysDataScope"
// @Success 200 {object} res.R[int64] "操作结果"
// @Router /sys_data_scope/edit [post]
func (h *SysDataScopeHandler) Edit(ctx *gin.Context) {
	var reqSys req_sys.SysDataScopeEditReq
	if err := ctx.ShouldBindJSON(&reqSys); err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	n, err := h.SysDataScopeService.Edit(ctx, reqSys)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	ctx.JSON(http.StatusOK, res.NewR[int64]().Ok(n))
}

// Delete 删除SysDataScope
// @Summary 删除SysDataScope
// @Tags SysDataScopeHandler
// @Accept json
// @Produce json
// @Param jsonParams body req.IdsReq true "ID集合"
// @Success 200 {object} res.R[int64] "操作结果"
// @Router /sys_data_scope/delete [post]
func (h *SysDataScopeHandler) Delete(ctx *gin.Context) {
	var idsReq req.IdsReq
	if err := ctx.ShouldBindJSON(&idsReq); err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	n, err := h.SysDataScopeService.Delete(ctx, idsReq)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	ctx.JSON(http.StatusOK, res.NewR[int64]().Ok(n))
}

// ResetToRole 重置所有角色数据范围权限（ALL）
// @Summary 重置所有角色数据范围权限（ALL）
// @Tags SysDataScopeHandler
// @Accept json
// @Produce json
// @Param scopeStr query string false "权限范围字符串"
// @Success 200 {object} res.R[string] "操作结果"
// @Router /sys_data_scope/reset-role [post]
func (h *SysDataScopeHandler) ResetToRole(ctx *gin.Context) {
	scopeStr := ctx.Query("scopeStr")
	if scopeStr == "" {
		scopeStr = "ALL"
	}
	retStr, err := h.SysDataScopeService.ResetToRole(ctx, scopeStr)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	ctx.JSON(http.StatusOK, res.NewR[string]().Ok(retStr))
}

// RoleList 查询该角色数据范围列表
// @Summary 查询该角色数据范围列表
// @Tags SysDataScopeHandler
// @Accept json
// @Produce json
// @Param role query string true "角色字典值"
// @Success 200 {object} res.R[[]res_sys.SysDataScopeRes] "操作结果"
// @Router /sys_data_scope/role-list [get]
func (h *SysDataScopeHandler) RoleList(ctx *gin.Context) {
	role := ctx.Query("role")
	roleList, err := h.SysDataScopeService.RoleList(ctx, role)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	ctx.JSON(http.StatusOK, res.NewR[[]*res_sys.SysDataScopeRes]().Ok(roleList))
}

// UserList 查询该用户数据范围列表
// @Summary 查询该用户数据范围列表
// @Tags SysDataScopeHandler
// @Accept json
// @Produce json
// @Param userID query int64 true "用户ID"
// @Success 200 {object} res.R[[]res_sys.SysDataScopeRes] "操作结果"
// @Router /sys_data_scope/user-list [get]
func (h *SysDataScopeHandler) UserList(ctx *gin.Context) {
	userIdQuery := ctx.Query("userID")
	userID, err := strconv.ParseInt(userIdQuery, 10, 64)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": "无效的ID"})
		return
	}
	roleList, err := h.SysDataScopeService.UserList(ctx, userID)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	ctx.JSON(http.StatusOK, res.NewR[[]*res_sys.SysDataScopeRes]().Ok(roleList))
}

// RoleSaveList 存储该角色数据范围列表
// @Summary 存储该角色数据范围列表
// @Tags SysDataScopeHandler
// @Accept json
// @Produce json
// @Param sysDataScopeRoleReq body req_sys.SysDataScopeRoleReq true "SysDataScopeRoleReq"
// @Success 200 {object} res.R[string] "操作结果"
// @Router /sys_data_scope/role/save [post]
func (h *SysDataScopeHandler) RoleSaveList(ctx *gin.Context) {
	var sysDataScopeRoleReq req_sys.SysDataScopeRoleReq
	if err := ctx.ShouldBindJSON(&sysDataScopeRoleReq); err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	okLen, err := h.SysDataScopeService.RoleSaveList(ctx, sysDataScopeRoleReq)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	ctx.JSON(http.StatusOK, res.NewR[string]().Ok(fmt.Sprintf("成功保存%d条数据", okLen)))
}

// UserSaveList 存储该用户数据范围列表
// @Summary 存储该用户数据范围列表
// @Tags SysDataScopeHandler
// @Accept json
// @Produce json
// @Param sysDataScopeUserReq body req_sys.SysDataScopeUserReq true "SysDataScopeRoleReq"
// @Success 200 {object} res.R[string] "操作结果"
// @Router /sys_data_scope/user/save [post]
func (h *SysDataScopeHandler) UserSaveList(ctx *gin.Context) {
	var sysDataScopeUserReq req_sys.SysDataScopeUserReq
	if err := ctx.ShouldBindJSON(&sysDataScopeUserReq); err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	okLen, err := h.SysDataScopeService.UserSaveList(ctx, sysDataScopeUserReq)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	ctx.JSON(http.StatusOK, res.NewR[string]().Ok(fmt.Sprintf("成功保存%d条数据", okLen)))
}
